/**
 * 命令依赖功能示例
 * 
 * 展示如何使用拓扑排序和命令依赖功能
 * 
 * @author AI Assistant
 * @date 2025-11-26
 */

import { ecs } from "../../../core/ecs/ECS";
import { Color } from "cc";
import { commandQueue, LogicCmd, LogicCmdDep } from "./index";

// ==================== 示例 1: 基础依赖 ====================

/**
 * 示例：动画序列依赖
 * 确保动画按顺序播放
 */
export function exampleAnimationSequence(entityId: number): void {
    console.log('\n=== 示例 1: 动画序列依赖 ===\n');
    
    // 启用依赖排序
    commandQueue.enableDependencySorting();
    
    // 1. 播放待机动画（无依赖）
    const idleCmd = LogicCmd.playAnimation(entityId, 'idle', true);
    console.log('1. 播放待机动画:', idleCmd);
    
    // 2. 播放攻击动画（依赖待机动画）
    const attackCmd = LogicCmdDep.playAnimation(entityId, 'attack', false, [idleCmd]);
    console.log('2. 播放攻击动画（依赖待机）:', attackCmd);
    
    // 3. 播放受击动画（依赖攻击动画）
    const hitCmd = LogicCmdDep.playAnimation(entityId, 'hit', false, [attackCmd]);
    console.log('3. 播放受击动画（依赖攻击）:', hitCmd);
    
    // 4. 返回待机动画（依赖受击动画）
    const backToIdleCmd = LogicCmdDep.playAnimation(entityId, 'idle', true, [hitCmd]);
    console.log('4. 返回待机动画（依赖受击）:', backToIdleCmd);
    
    console.log('\n执行顺序将自动按依赖关系排序');
}

// ==================== 示例 2: 多实体协调 ====================

/**
 * 示例：多个实体的协调动作
 * 确保 B 在 A 之后移动
 */
export function exampleMultiEntityCoordination(entityA: number, entityB: number): void {
    console.log('\n=== 示例 2: 多实体协调 ===\n');
    
    commandQueue.enableDependencySorting();
    
    // A 移动到位置 1
    const moveA1 = LogicCmd.setPosition(entityA, 100, 100);
    console.log('A 移动到 (100, 100):', moveA1);
    
    // B 等 A 移动后再移动
    const moveB1 = LogicCmdDep.setPosition(entityB, 200, 100, 0, [moveA1]);
    console.log('B 移动到 (200, 100)（依赖 A）:', moveB1);
    
    // A 移动到位置 2（依赖 B 的移动）
    const moveA2 = LogicCmdDep.setPosition(entityA, 300, 100, 0, [moveB1]);
    console.log('A 移动到 (300, 100)（依赖 B）:', moveA2);
    
    // B 移动到位置 2（依赖 A 的第二次移动）
    const moveB2 = LogicCmdDep.setPosition(entityB, 400, 100, 0, [moveA2]);
    console.log('B 移动到 (400, 100)（依赖 A）:', moveB2);
    
    console.log('\n结果：A 和 B 将交替移动');
}

// ==================== 示例 3: UI 更新依赖 ====================

/**
 * 示例：UI 更新链
 * 分数 → 等级 → 称号 依次更新
 */
export function exampleUIUpdateChain(scoreUI: number, levelUI: number, titleUI: number): void {
    console.log('\n=== 示例 3: UI 更新链 ===\n');
    
    commandQueue.enableDependencySorting();
    
    // 1. 更新分数
    const updateScore = LogicCmd.setLabelText(scoreUI, 'Score: 1000');
    console.log('1. 更新分数:', updateScore);
    
    // 2. 更新等级（依赖分数更新）
    const updateLevel = LogicCmdDep.setLabelText(levelUI, 'Level: 5', [updateScore]);
    console.log('2. 更新等级（依赖分数）:', updateLevel);
    
    // 3. 更新称号（依赖等级更新）
    const updateTitle = LogicCmdDep.setLabelText(titleUI, 'Title: Master', [updateLevel]);
    console.log('3. 更新称号（依赖等级）:', updateTitle);
    
    // 4. 改变称号颜色（依赖称号更新）
    const colorTitle = LogicCmdDep.setSpriteColor(
        titleUI,
        new Color(255, 215, 0), // 金色
        [updateTitle]
    );
    console.log('4. 改变称号颜色（依赖称号）:', colorTitle);
    
    console.log('\n结果：UI 将按 分数→等级→称号→颜色 的顺序更新');
}

// ==================== 示例 4: 复杂依赖图 ====================

/**
 * 示例：菱形依赖
 * 
 *     A
 *    / \
 *   B   C
 *    \ /
 *     D
 */
export function exampleDiamondDependency(entity: number): void {
    console.log('\n=== 示例 4: 菱形依赖 ===\n');
    
    commandQueue.enableDependencySorting();
    
    // A: 初始位置
    const cmdA = LogicCmd.setPosition(entity, 0, 0);
    console.log('A: 移动到 (0, 0):', cmdA);
    
    // B 和 C 都依赖 A
    const cmdB = LogicCmdDep.setPosition(entity, 100, 0, 0, [cmdA]);
    const cmdC = LogicCmdDep.setPosition(entity, 0, 100, 0, [cmdA]);
    console.log('B: 移动到 (100, 0)（依赖 A）:', cmdB);
    console.log('C: 移动到 (0, 100)（依赖 A）:', cmdC);
    
    // D 依赖 B 和 C
    const cmdD = LogicCmdDep.setPosition(entity, 100, 100, 0, [cmdB, cmdC]);
    console.log('D: 移动到 (100, 100)（依赖 B 和 C）:', cmdD);
    
    console.log('\n结果：A → (B, C) → D 的顺序执行');
}

// ==================== 示例 5: 命令分组 ====================

/**
 * 示例：使用命令分组管理依赖
 */
export function exampleCommandGroups(entities: number[]): void {
    console.log('\n=== 示例 5: 命令分组 ===\n');
    
    commandQueue.enableDependencySorting();
    
    // 第一组：初始化命令
    const initCommands: string[] = [];
    for (let i = 0; i < entities.length; i++) {
        const cmdId = LogicCmd.setPosition(entities[i], i * 100, 0);
        initCommands.push(cmdId);
    }
    commandQueue.createCommandGroup('init', initCommands);
    console.log('创建初始化组:', initCommands);
    
    // 第二组：显示命令（依赖初始化组）
    const showCommands: string[] = [];
    for (let i = 0; i < entities.length; i++) {
        const cmdId = LogicCmd.show(entities[i]);
        showCommands.push(cmdId);
    }
    commandQueue.createCommandGroup('show', showCommands);
    console.log('创建显示组:', showCommands);
    
    // 添加分组依赖
    commandQueue.addGroupDependency('show', 'init');
    console.log('显示组依赖初始化组');
    
    console.log('\n结果：所有初始化完成后，才会执行显示');
}

// ==================== 示例 6: 检测循环依赖 ====================

/**
 * 示例：故意创建循环依赖并检测
 */
export function exampleCycleDetection(entity: number): void {
    console.log('\n=== 示例 6: 循环依赖检测 ===\n');
    
    commandQueue.enableDependencySorting();
    
    // 创建一些命令
    const cmd1 = LogicCmd.setPosition(entity, 100, 0);
    const cmd2 = LogicCmd.setPosition(entity, 200, 0);
    const cmd3 = LogicCmd.setPosition(entity, 300, 0);
    
    console.log('命令 1:', cmd1);
    console.log('命令 2:', cmd2);
    console.log('命令 3:', cmd3);
    
    // 尝试创建循环：1 → 2 → 3 → 1
    // 注意：由于我们的实现会在执行前检测循环，这里只是演示
    
    console.log('\n检测循环依赖...');
    const cycles = commandQueue.detectCycles();
    
    if (cycles.length > 0) {
        console.error('发现循环依赖:');
        cycles.forEach((cycle, index) => {
            console.error(`  循环 ${index + 1}: ${cycle.join(' → ')}`);
        });
    } else {
        console.log('✅ 没有循环依赖');
    }
}

// ==================== 示例 7: 可视化依赖图 ====================

/**
 * 示例：生成依赖图可视化
 */
export function exampleVisualizeDependencies(entity: number): void {
    console.log('\n=== 示例 7: 依赖图可视化 ===\n');
    
    commandQueue.enableDependencySorting();
    
    // 创建一些有依赖的命令
    const cmd1 = LogicCmd.setPosition(entity, 0, 0);
    const cmd2 = LogicCmdDep.setPosition(entity, 100, 0, 0, [cmd1]);
    const cmd3 = LogicCmdDep.setPosition(entity, 200, 0, 0, [cmd1]);
    const cmd4 = LogicCmdDep.setPosition(entity, 300, 0, 0, [cmd2, cmd3]);
    
    // 生成 Mermaid 格式的可视化
    const mermaid = commandQueue.visualizeDependencies();
    
    console.log('依赖图（Mermaid 格式）：\n');
    console.log(mermaid);
    console.log('\n将此内容复制到 Mermaid 在线编辑器查看图形');
}

// ==================== 示例 8: 完整的游戏场景 ====================

/**
 * 示例：完整的游戏场景 - 玩家击败敌人
 */
export function exampleCompleteGameScene(playerId: number, enemyId: number, scoreUIId: number): void {
    console.log('\n=== 示例 8: 完整游戏场景 ===\n');
    
    commandQueue.enableDependencySorting();
    
    // 1. 玩家移动到敌人位置
    const playerMove = LogicCmd.setPosition(playerId, 100, 100);
    console.log('1. 玩家移动:', playerMove);
    
    // 2. 播放攻击动画（依赖移动完成）
    const playerAttack = LogicCmdDep.playAnimation(playerId, 'attack', false, [playerMove]);
    console.log('2. 玩家攻击:', playerAttack);
    
    // 3. 敌人播放受击动画（依赖玩家攻击）
    const enemyHit = LogicCmdDep.playAnimation(enemyId, 'hit', false, [playerAttack]);
    console.log('3. 敌人受击:', enemyHit);
    
    // 4. 敌人播放死亡动画（依赖受击动画）
    const enemyDeath = LogicCmdDep.playAnimation(enemyId, 'death', false, [enemyHit]);
    console.log('4. 敌人死亡:', enemyDeath);
    
    // 5. 隐藏敌人（依赖死亡动画）
    const enemyHide = LogicCmdDep.setVisible(enemyId, false, [enemyDeath]);
    console.log('5. 隐藏敌人:', enemyHide);
    
    // 6. 更新分数（依赖敌人隐藏）
    const updateScore = LogicCmdDep.setLabelText(scoreUIId, 'Score: +100', [enemyHide]);
    console.log('6. 更新分数:', updateScore);
    
    // 7. 玩家返回待机（依赖分数更新）
    const playerIdle = LogicCmdDep.playAnimation(playerId, 'idle', true, [updateScore]);
    console.log('7. 玩家待机:', playerIdle);
    
    console.log('\n结果：整个战斗流程将按正确顺序执行');
    
    // 打印依赖图
    commandQueue.printDependencyGraph();
}

// ==================== 导出示例集合 ====================

export const DependencyExamples = {
    animationSequence: exampleAnimationSequence,
    multiEntityCoordination: exampleMultiEntityCoordination,
    uiUpdateChain: exampleUIUpdateChain,
    diamondDependency: exampleDiamondDependency,
    commandGroups: exampleCommandGroups,
    cycleDetection: exampleCycleDetection,
    visualizeDependencies: exampleVisualizeDependencies,
    completeGameScene: exampleCompleteGameScene
};

// 使用示例：
// import { DependencyExamples } from 'db://assets/scripts/ecs/command/CommandDependencyExample';
// DependencyExamples.animationSequence(entityId);
// DependencyExamples.completeGameScene(playerId, enemyId, scoreUIId);

